package org.common.utils.tool;
import java.lang.reflect.Method;
import java.util.*;

/**
 * 集合工具类
 * @author zhouzhibing
 * @date 2025/4/11
 */
public class CollectionTool {

    /**
     * 空列表
     */
    private static final List<?> EMPTY_LIST = new ArrayList<>();

    /**
     * 判断一个数组是否为空
     * @param array 数组
     * @return true为空，false不为空
     */
    public static boolean isEmpty(Object[] array){
        return array == null || array.length == 0;
    }

    /**
     * 判断一个集合是否为空
     * @param collection 集合
     * @return true为空，false不为空
     */
    public static boolean isEmpty(Collection<?> collection){
        return collection == null || collection.isEmpty();
    }

    /**
     * 判断一个map是否为空
     * @param map map列表
     * @return true为空，false不为空
     */
    public static boolean isEmpty(Map<? , ?> map){
        return map == null || map.isEmpty();
    }

    /**
     * Set集合分批
     * @param original 原始集合
     * @param batchSize 分批大小列表
     * @return 分批集合列表
     * @param <T> 集合元素类型
     */
    public static <T> List<Set<T>> splitSet(Set<T> original , int batchSize) {
        int batchCount = original.size() / batchSize + 1;
        List<Set<T>> batchList = new ArrayList<>(batchCount);
        Set<T> newSet = new HashSet<>();
        for (T t : original) {
            newSet.add(t);
            if (newSet.size() == batchSize) {
                batchList.add(newSet);
                newSet = new HashSet<>();
            }
        }
        if (!newSet.isEmpty()) {
            batchList.add(newSet);
        }
        return batchList;
    }

    /**
     * Set集合分批
     * @param original 原始集合
     * @param batchSize 分批大小列表
     * @return 分批集合列表
     * @param <T> 集合元素类型
     */
    public static <T> List<List<T>> splitList(List<T> original , int batchSize) {
        int batchCount = original.size() / batchSize + 1;
        List<List<T>> batchList = new ArrayList<>(batchCount);
        List<T> newList = new ArrayList<>();
        for (T t : original) {
            newList.add(t);
            if (newList.size() == batchSize) {
                batchList.add(newList);
                newList = new ArrayList<>();
            }
        }
        if (!newList.isEmpty()) {
            batchList.add(newList);
        }
        return batchList;
    }

    /**
     * MAP集合分批
     * @param original 原始集合
     * @param batchSize 分批大小列表
     * @return 分批集合列表
     * @param <K> 集合元素类型
     * @param <V> 集合元素类型
     */
    public static <K , V> List<Map<K , V>> splitMap(Map<K , V> original , int batchSize) {
        int batchCount = original.size() / batchSize + 1;
        List<Map<K , V>> batchList = new ArrayList<>(batchCount);
        Map<K , V> newMap = new HashMap<>();

        for (Map.Entry<K, V> entry : original.entrySet()) {
            K key = entry.getKey();
            V value = entry.getValue();
            newMap.put(key , value);

            if (newMap.size() == batchSize) {
                batchList.add(newMap);
                newMap = new HashMap<>();
            }
        }
        if (!newMap.isEmpty()) {
            batchList.add(newMap);
        }
        return batchList;
    }


    /**
     * @return 获取一个空列表
     */
    public static <T> List<T> emtpyList() {
        return (List<T>)EMPTY_LIST;
    }
}
